home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2001 May / SGI Freeware 2001 May - Disc 2.iso / dist / fw_libxml.idb / usr / freeware / include / gnome-xml / tree.h.z / tree.h
C/C++ Source or Header  |  2001-04-12  |  17KB  |  581 lines
  1. /*
  2.  * tree.h : describes the structures found in an tree resulting
  3.  *          from an XML parsing.
  4.  *
  5.  * See Copyright for the status of this software.
  6.  *
  7.  * Daniel.Veillard@w3.org
  8.  */
  9.  
  10. #ifndef __XML_TREE_H__
  11. #define __XML_TREE_H__
  12.  
  13. #include <stdio.h>
  14.  
  15.  
  16. #ifdef __cplusplus
  17. extern "C" {
  18. #endif
  19.  
  20. /*
  21.  * use those to be sure nothing nasty will happen if
  22.  * your library and includes mismatch
  23.  */
  24. extern void xmlCheckVersion(int version);
  25. #define LIBXML_VERSION_NUMBER 10808
  26. #define LIBXML_TEST_VERSION xmlCheckVersion(LIBXML_VERSION_NUMBER);
  27.  
  28.  
  29. /*
  30.  * The different element types carried by an XML tree
  31.  *
  32.  * NOTE: This is synchronized with DOM Level1 values
  33.  *       See http://www.w3.org/TR/REC-DOM-Level-1/
  34.  */
  35. typedef enum {
  36.     XML_ELEMENT_NODE=        1,
  37.     XML_ATTRIBUTE_NODE=        2,
  38.     XML_TEXT_NODE=        3,
  39.     XML_CDATA_SECTION_NODE=    4,
  40.     XML_ENTITY_REF_NODE=    5,
  41.     XML_ENTITY_NODE=        6,
  42.     XML_PI_NODE=        7,
  43.     XML_COMMENT_NODE=        8,
  44.     XML_DOCUMENT_NODE=        9,
  45.     XML_DOCUMENT_TYPE_NODE=    10,
  46.     XML_DOCUMENT_FRAG_NODE=    11,
  47.     XML_NOTATION_NODE=        12,
  48.     XML_HTML_DOCUMENT_NODE=    13
  49. } xmlElementType;
  50.  
  51. /*
  52.  * Size of an internal character representation.
  53.  *
  54.  * Currently we use 8bit chars internal representation for memory efficiency,
  55.  * but the parser is not tied to that, just define UNICODE to switch to
  56.  * a 16 bits internal representation. Note that with 8 bits wide
  57.  * xmlChars one can still use UTF-8 to handle correctly non ISO-Latin
  58.  * input.
  59.  */
  60.  
  61. #ifdef UNICODE
  62. typedef unsigned short xmlChar;
  63. #else
  64. typedef unsigned char xmlChar;
  65. #endif
  66.  
  67. #ifndef WIN32
  68. #ifndef CHAR
  69. #define CHAR xmlChar
  70. #endif
  71. #endif
  72.  
  73. #define BAD_CAST (xmlChar *)
  74.  
  75. /*
  76.  * a DTD Notation definition
  77.  */
  78.  
  79. typedef struct _xmlNotation xmlNotation;
  80. typedef xmlNotation *xmlNotationPtr;
  81. struct _xmlNotation {
  82.     const xmlChar               *name;    /* Notation name */
  83.     const xmlChar               *PublicID;    /* Public identifier, if any */
  84.     const xmlChar               *SystemID;    /* System identifier, if any */
  85. };
  86.  
  87. /*
  88.  * a DTD Attribute definition
  89.  */
  90.  
  91. typedef enum {
  92.     XML_ATTRIBUTE_CDATA = 1,
  93.     XML_ATTRIBUTE_ID,
  94.     XML_ATTRIBUTE_IDREF    ,
  95.     XML_ATTRIBUTE_IDREFS,
  96.     XML_ATTRIBUTE_ENTITY,
  97.     XML_ATTRIBUTE_ENTITIES,
  98.     XML_ATTRIBUTE_NMTOKEN,
  99.     XML_ATTRIBUTE_NMTOKENS,
  100.     XML_ATTRIBUTE_ENUMERATION,
  101.     XML_ATTRIBUTE_NOTATION
  102. } xmlAttributeType;
  103.  
  104. typedef enum {
  105.     XML_ATTRIBUTE_NONE = 1,
  106.     XML_ATTRIBUTE_REQUIRED,
  107.     XML_ATTRIBUTE_IMPLIED,
  108.     XML_ATTRIBUTE_FIXED
  109. } xmlAttributeDefault;
  110.  
  111. typedef struct _xmlEnumeration xmlEnumeration;
  112. typedef xmlEnumeration *xmlEnumerationPtr;
  113. struct _xmlEnumeration {
  114.     struct _xmlEnumeration    *next;    /* next one */
  115.     const xmlChar            *name;    /* Enumeration name */
  116. };
  117.  
  118. typedef struct _xmlAttribute xmlAttribute;
  119. typedef xmlAttribute *xmlAttributePtr;
  120. struct _xmlAttribute {
  121.     const xmlChar         *elem;    /* Element holding the attribute */
  122.     const xmlChar         *name;    /* Attribute name */
  123.     struct _xmlAttribute   *next;       /* list of attributes of an element */
  124.     xmlAttributeType       type;    /* The type */
  125.     xmlAttributeDefault    def;        /* the default */
  126.     const xmlChar         *defaultValue;/* or the default value */
  127.     xmlEnumerationPtr      tree;        /* or the enumeration tree if any */
  128.     const xmlChar         *prefix;      /* the namespace prefix if any */
  129. };
  130.  
  131. /*
  132.  * a DTD Element definition.
  133.  */
  134. typedef enum {
  135.     XML_ELEMENT_CONTENT_PCDATA = 1,
  136.     XML_ELEMENT_CONTENT_ELEMENT,
  137.     XML_ELEMENT_CONTENT_SEQ,
  138.     XML_ELEMENT_CONTENT_OR
  139. } xmlElementContentType;
  140.  
  141. typedef enum {
  142.     XML_ELEMENT_CONTENT_ONCE = 1,
  143.     XML_ELEMENT_CONTENT_OPT,
  144.     XML_ELEMENT_CONTENT_MULT,
  145.     XML_ELEMENT_CONTENT_PLUS
  146. } xmlElementContentOccur;
  147.  
  148. typedef struct _xmlElementContent xmlElementContent;
  149. typedef xmlElementContent *xmlElementContentPtr;
  150. struct _xmlElementContent {
  151.     xmlElementContentType     type;    /* PCDATA, ELEMENT, SEQ or OR */
  152.     xmlElementContentOccur    ocur;    /* ONCE, OPT, MULT or PLUS */
  153.     const xmlChar            *name;    /* Element name */
  154.     struct _xmlElementContent *c1;    /* first child */
  155.     struct _xmlElementContent *c2;    /* second child */
  156. };
  157.  
  158. typedef enum {
  159.     XML_ELEMENT_TYPE_EMPTY = 1,
  160.     XML_ELEMENT_TYPE_ANY,
  161.     XML_ELEMENT_TYPE_MIXED,
  162.     XML_ELEMENT_TYPE_ELEMENT
  163. } xmlElementTypeVal;
  164.  
  165. typedef struct _xmlElement xmlElement;
  166. typedef xmlElement *xmlElementPtr;
  167. struct _xmlElement {
  168.     const xmlChar          *name;    /* Element name */
  169.     xmlElementTypeVal       type;    /* The type */
  170.     xmlElementContentPtr content;    /* the allowed element content */
  171.     xmlAttributePtr   attributes;    /* List of the declared attributes */
  172. };
  173.  
  174. /*
  175.  * An XML namespace.
  176.  * Note that prefix == NULL is valid, it defines the default namespace
  177.  * within the subtree (until overriden).
  178.  */
  179.  
  180. typedef enum {
  181.     XML_GLOBAL_NAMESPACE = 1,    /* old style global namespace */
  182.     XML_LOCAL_NAMESPACE        /* new style local scoping */
  183. } xmlNsType;
  184.  
  185. typedef struct _xmlNs xmlNs;
  186. typedef xmlNs *xmlNsPtr;
  187. struct _xmlNs {
  188.     struct _xmlNs  *next;    /* next Ns link for this node  */
  189.     xmlNsType      type;    /* global or local */
  190.     const xmlChar *href;    /* URL for the namespace */
  191.     const xmlChar *prefix;    /* prefix for the namespace */
  192. };
  193.  
  194. /*
  195.  * An XML DtD, as defined by <!DOCTYPE.
  196.  */
  197. typedef struct _xmlDtd xmlDtd;
  198. typedef xmlDtd *xmlDtdPtr;
  199. struct _xmlDtd {
  200.     const xmlChar *name;    /* Name of the DTD */
  201.     const xmlChar *ExternalID;    /* External identifier for PUBLIC DTD */
  202.     const xmlChar *SystemID;    /* URI for a SYSTEM or PUBLIC DTD */
  203.     void          *notations;   /* Hash table for notations if any */
  204.     void          *elements;    /* Hash table for elements if any */
  205.     void          *attributes;  /* Hash table for attributes if any */
  206.     void          *entities;    /* Hash table for entities if any */
  207.     /* struct xmlDtd *next;     * next  link for this document  */
  208. };
  209.  
  210. /*
  211.  * A attribute of an XML node.
  212.  */
  213. typedef struct _xmlAttr xmlAttr;
  214. typedef xmlAttr *xmlAttrPtr;
  215. struct _xmlAttr {
  216. #ifndef XML_WITHOUT_CORBA
  217.     void           *_private;    /* for Corba, must be first ! */
  218.     void           *vepv;    /* for Corba, must be next ! */
  219. #endif
  220.     xmlElementType  type;       /* XML_ATTRIBUTE_NODE, must be third ! */
  221.     struct _xmlNode *node;    /* attr->node link */
  222.     struct _xmlAttr *next;    /* attribute list link */
  223.     const xmlChar   *name;      /* the name of the property */
  224.     struct _xmlNode *val;       /* the value of the property */
  225.     xmlNs           *ns;        /* pointer to the associated namespace */
  226. };
  227.  
  228. /*
  229.  * An XML ID instance.
  230.  */
  231.  
  232. typedef struct _xmlID xmlID;
  233. typedef xmlID *xmlIDPtr;
  234. struct _xmlID {
  235.     struct _xmlID    *next;    /* next ID */
  236.     const xmlChar    *value;    /* The ID name */
  237.     xmlAttrPtr        attr;    /* The attribut holding it */
  238. };
  239.  
  240. /*
  241.  * An XML IDREF instance.
  242.  */
  243.  
  244. typedef struct _xmlRef xmlRef;
  245. typedef xmlRef *xmlRefPtr;
  246. struct _xmlRef {
  247.     struct _xmlRef    *next;    /* next Ref */
  248.     const xmlChar     *value;    /* The Ref name */
  249.     xmlAttrPtr        attr;    /* The attribut holding it */
  250. };
  251.  
  252. /*
  253.  * A buffer structure
  254.  */
  255.  
  256. typedef enum {
  257.     XML_BUFFER_ALLOC_DOUBLEIT,
  258.     XML_BUFFER_ALLOC_EXACT
  259. } xmlBufferAllocationScheme;
  260.  
  261. typedef struct _xmlBuffer xmlBuffer;
  262. typedef xmlBuffer *xmlBufferPtr;
  263. struct _xmlBuffer {
  264.     xmlChar *content;        /* The buffer content UTF8 */
  265.     unsigned int use;        /* The buffer size used */
  266.     unsigned int size;        /* The buffer size */
  267.     xmlBufferAllocationScheme alloc; /* The realloc method */
  268. };
  269.  
  270. /*
  271.  * A node in an XML tree.
  272.  */
  273. typedef struct _xmlNode xmlNode;
  274. typedef xmlNode *xmlNodePtr;
  275. struct _xmlNode {
  276. #ifndef XML_WITHOUT_CORBA
  277.     void           *_private;    /* for Corba, must be first ! */
  278.     void           *vepv;    /* for Corba, must be next ! */
  279. #endif
  280.     xmlElementType  type;    /* type number in the DTD, must be third ! */
  281.     struct _xmlDoc  *doc;    /* the containing document */
  282.     struct _xmlNode *parent;    /* child->parent link */
  283.     struct _xmlNode *next;    /* next sibling link  */
  284.     struct _xmlNode *prev;    /* previous sibling link  */
  285.     struct _xmlNode *childs;    /* parent->childs link */
  286.     struct _xmlNode *last;    /* last child link */
  287.     struct _xmlAttr *properties;/* properties list */
  288.     const xmlChar  *name;       /* the name of the node, or the entity */
  289.     xmlNs          *ns;         /* pointer to the associated namespace */
  290.     xmlNs          *nsDef;      /* namespace definitions on this node */
  291. #ifndef XML_USE_BUFFER_CONTENT    
  292.     xmlChar        *content;    /* the content */
  293. #else
  294.     xmlBufferPtr   content;     /* the content in a buffer */
  295. #endif
  296. };
  297.  
  298. /*
  299.  * An XML document.
  300.  */
  301. typedef struct _xmlDoc xmlDoc;
  302. typedef xmlDoc *xmlDocPtr;
  303. struct _xmlDoc {
  304. #ifndef XML_WITHOUT_CORBA
  305.     void           *_private;    /* for Corba, must be first ! */
  306.     void           *vepv;    /* for Corba, must be next ! */
  307. #endif
  308.     xmlElementType  type;       /* XML_DOCUMENT_NODE, must be second ! */
  309.     char           *name;    /* name/filename/URI of the document */
  310.     const xmlChar  *version;    /* the XML version string */
  311.     const xmlChar  *encoding;   /* encoding, if any */
  312.     int             compression;/* level of zlib compression */
  313.     int             standalone; /* standalone document (no external refs) */
  314.     struct _xmlDtd  *intSubset;    /* the document internal subset */
  315.     struct _xmlDtd  *extSubset;    /* the document external subset */
  316.     struct _xmlNs   *oldNs;    /* Global namespace, the old way */
  317.     struct _xmlNode *root;    /* the document tree */
  318.     void           *ids;        /* Hash table for ID attributes if any */
  319.     void           *refs;       /* Hash table for IDREFs attributes if any */
  320. };
  321.  
  322. /*
  323.  * Compatibility naming layer with libxml1
  324.  */
  325. #ifndef xmlChildrenNode
  326. #define xmlChildrenNode childs
  327. #define xmlRootNode root
  328. #endif
  329.  
  330. /*
  331.  * Variables.
  332.  */
  333. extern xmlNsPtr baseDTD;
  334. extern int oldXMLWDcompatibility;/* maintain compatibility with old WD */
  335. extern int xmlIndentTreeOutput;  /* try to indent the tree dumps */
  336. extern xmlBufferAllocationScheme xmlBufferAllocScheme; /* alloc scheme to use */
  337. extern int xmlSaveNoEmptyTags;   /* save empty tags as <empty></empty> */
  338.  
  339. /*
  340.  * Handling Buffers.
  341.  */
  342.  
  343. xmlBufferPtr    xmlBufferCreate        (void);
  344. xmlBufferPtr    xmlBufferCreateSize    (size_t size);
  345. void        xmlBufferFree        (xmlBufferPtr buf);
  346. int        xmlBufferDump        (FILE *file,
  347.                      xmlBufferPtr buf);
  348. void        xmlBufferAdd        (xmlBufferPtr buf,
  349.                      const xmlChar *str,
  350.                      int len);
  351. void        xmlBufferCat        (xmlBufferPtr buf,
  352.                      const xmlChar *str);
  353. void        xmlBufferCCat        (xmlBufferPtr buf,
  354.                      const char *str);
  355. int        xmlBufferShrink        (xmlBufferPtr buf,
  356.                      int len);
  357. void        xmlBufferEmpty        (xmlBufferPtr buf);
  358. const xmlChar*    xmlBufferContent    (const xmlBufferPtr buf);
  359. int        xmlBufferUse        (const xmlBufferPtr buf);
  360. void        xmlBufferSetAllocationScheme(xmlBufferPtr buf,
  361.                      xmlBufferAllocationScheme scheme);
  362. int        xmlBufferLength        (const xmlBufferPtr buf);
  363.  
  364. /*
  365.  * Creating/freeing new structures
  366.  */
  367. xmlDtdPtr    xmlCreateIntSubset    (xmlDocPtr doc,
  368.                      const xmlChar *name,
  369.                      const xmlChar *ExternalID,
  370.                      const xmlChar *SystemID);
  371. xmlDtdPtr    xmlNewDtd        (xmlDocPtr doc,
  372.                      const xmlChar *name,
  373.                      const xmlChar *ExternalID,
  374.                      const xmlChar *SystemID);
  375. void        xmlFreeDtd        (xmlDtdPtr cur);
  376. xmlNsPtr    xmlNewGlobalNs        (xmlDocPtr doc,
  377.                      const xmlChar *href,
  378.                      const xmlChar *prefix);
  379. xmlNsPtr    xmlNewNs        (xmlNodePtr node,
  380.                      const xmlChar *href,
  381.                      const xmlChar *prefix);
  382. void        xmlFreeNs        (xmlNsPtr cur);
  383. xmlDocPtr     xmlNewDoc        (const xmlChar *version);
  384. void        xmlFreeDoc        (xmlDocPtr cur);
  385. xmlAttrPtr    xmlNewDocProp        (xmlDocPtr doc,
  386.                      const xmlChar *name,
  387.                      const xmlChar *value);
  388. xmlAttrPtr    xmlNewProp        (xmlNodePtr node,
  389.                      const xmlChar *name,
  390.                      const xmlChar *value);
  391. xmlAttrPtr    xmlNewNsProp        (xmlNodePtr node,
  392.                      xmlNsPtr ns,
  393.                      const xmlChar *name,
  394.                      const xmlChar *value);
  395. void        xmlFreePropList        (xmlAttrPtr cur);
  396. void        xmlFreeProp        (xmlAttrPtr cur);
  397. xmlAttrPtr    xmlCopyProp        (xmlNodePtr target,
  398.                      xmlAttrPtr cur);
  399. xmlAttrPtr    xmlCopyPropList        (xmlNodePtr target,
  400.                      xmlAttrPtr cur);
  401. xmlDtdPtr    xmlCopyDtd        (xmlDtdPtr dtd);
  402. xmlDocPtr    xmlCopyDoc        (xmlDocPtr doc,
  403.                      int recursive);
  404.  
  405. /*
  406.  * Creating new nodes
  407.  */
  408. xmlNodePtr    xmlNewDocNode        (xmlDocPtr doc,
  409.                      xmlNsPtr ns,
  410.                      const xmlChar *name,
  411.                      const xmlChar *content);
  412. xmlNodePtr    xmlNewDocRawNode    (xmlDocPtr doc,
  413.                      xmlNsPtr ns,
  414.                      const xmlChar *name,
  415.                      const xmlChar *content);
  416. xmlNodePtr    xmlNewNode        (xmlNsPtr ns,
  417.                      const xmlChar *name);
  418. xmlNodePtr    xmlNewChild        (xmlNodePtr parent,
  419.                      xmlNsPtr ns,
  420.                      const xmlChar *name,
  421.                      const xmlChar *content);
  422. xmlNodePtr    xmlNewTextChild        (xmlNodePtr parent,
  423.                      xmlNsPtr ns,
  424.                      const xmlChar *name,
  425.                      const xmlChar *content);
  426. xmlNodePtr    xmlNewDocText        (xmlDocPtr doc,
  427.                      const xmlChar *content);
  428. xmlNodePtr    xmlNewText        (const xmlChar *content);
  429. xmlNodePtr    xmlNewPI        (const xmlChar *name,
  430.                      const xmlChar *content);
  431. xmlNodePtr    xmlNewDocTextLen    (xmlDocPtr doc,
  432.                      const xmlChar *content,
  433.                      int len);
  434. xmlNodePtr    xmlNewTextLen        (const xmlChar *content,
  435.                      int len);
  436. xmlNodePtr    xmlNewDocComment    (xmlDocPtr doc,
  437.                      const xmlChar *content);
  438. xmlNodePtr    xmlNewComment        (const xmlChar *content);
  439. xmlNodePtr    xmlNewCDataBlock    (xmlDocPtr doc,
  440.                      const xmlChar *content,
  441.                      int len);
  442. xmlNodePtr    xmlNewReference        (xmlDocPtr doc,
  443.                      const xmlChar *name);
  444. xmlNodePtr    xmlCopyNode        (xmlNodePtr node,
  445.                      int recursive);
  446. xmlNodePtr    xmlCopyNodeList        (xmlNodePtr node);
  447. xmlNodePtr    xmlNewDocFragment    (xmlDocPtr doc);
  448.  
  449. /*
  450.  * Navigating
  451.  */
  452. xmlNodePtr    xmlDocGetRootElement    (xmlDocPtr doc);
  453. xmlNodePtr    xmlGetLastChild        (xmlNodePtr parent);
  454. int        xmlNodeIsText        (xmlNodePtr node);
  455. int        xmlIsBlankNode        (xmlNodePtr node);
  456.  
  457. /*
  458.  * Changing the structure
  459.  */
  460. xmlNodePtr    xmlDocSetRootElement    (xmlDocPtr doc,
  461.                      xmlNodePtr root);
  462. void        xmlNodeSetName        (xmlNodePtr cur,
  463.                      const xmlChar *name);
  464. xmlNodePtr    xmlAddChild        (xmlNodePtr parent,
  465.                      xmlNodePtr cur);
  466. xmlNodePtr    xmlReplaceNode        (xmlNodePtr old,
  467.                      xmlNodePtr cur);
  468. xmlNodePtr    xmlAddSibling        (xmlNodePtr cur,
  469.                      xmlNodePtr elem);
  470. xmlNodePtr    xmlAddPrevSibling    (xmlNodePtr cur,
  471.                      xmlNodePtr elem);
  472. xmlNodePtr    xmlAddNextSibling    (xmlNodePtr cur,
  473.                      xmlNodePtr elem);
  474. void        xmlUnlinkNode        (xmlNodePtr cur);
  475. xmlNodePtr    xmlTextMerge        (xmlNodePtr first,
  476.                      xmlNodePtr second);
  477. void        xmlTextConcat        (xmlNodePtr node,
  478.                      const xmlChar *content,
  479.                      int len);
  480. void        xmlFreeNodeList        (xmlNodePtr cur);
  481. void        xmlFreeNode        (xmlNodePtr cur);
  482. int        xmlRemoveProp        (xmlAttrPtr cur);
  483.  
  484. /*
  485.  * Namespaces
  486.  */
  487. xmlNsPtr    xmlSearchNs        (xmlDocPtr doc,
  488.                      xmlNodePtr node,
  489.                      const xmlChar *nameSpace);
  490. xmlNsPtr    xmlSearchNsByHref    (xmlDocPtr doc,
  491.                      xmlNodePtr node,
  492.                      const xmlChar *href);
  493. xmlNsPtr *    xmlGetNsList        (xmlDocPtr doc,
  494.                      xmlNodePtr node);
  495. void        xmlSetNs        (xmlNodePtr node,
  496.                      xmlNsPtr ns);
  497. xmlNsPtr    xmlCopyNamespace    (xmlNsPtr cur);
  498. xmlNsPtr    xmlCopyNamespaceList    (xmlNsPtr cur);
  499.  
  500. /*
  501.  * Changing the content.
  502.  */
  503. xmlAttrPtr    xmlSetProp        (xmlNodePtr node,
  504.                      const xmlChar *name,
  505.                      const xmlChar *value);
  506. xmlChar *    xmlGetProp        (xmlNodePtr node,
  507.                      const xmlChar *name);
  508. xmlChar *    xmlGetNsProp        (xmlNodePtr node,
  509.                      const xmlChar *name,
  510.                      const xmlChar *nameSpace);
  511. xmlNodePtr    xmlStringGetNodeList    (xmlDocPtr doc,
  512.                      const xmlChar *value);
  513. xmlNodePtr    xmlStringLenGetNodeList    (xmlDocPtr doc,
  514.                      const xmlChar *value,
  515.                      int len);
  516. xmlChar *    xmlNodeListGetString    (xmlDocPtr doc,
  517.                      xmlNodePtr list,
  518.                      int inLine);
  519. void        xmlNodeSetContent    (xmlNodePtr cur,
  520.                      const xmlChar *content);
  521. void        xmlNodeSetContentLen    (xmlNodePtr cur,
  522.                      const xmlChar *content,
  523.                      int len);
  524. void        xmlNodeAddContent    (xmlNodePtr cur,
  525.                      const xmlChar *content);
  526. void        xmlNodeAddContentLen    (xmlNodePtr cur,
  527.                      const xmlChar *content,
  528.                      int len);
  529. xmlChar *    xmlNodeGetContent    (xmlNodePtr cur);
  530. xmlChar *    xmlNodeGetLang        (xmlNodePtr cur);
  531. void        xmlNodeSetLang        (xmlNodePtr cur,
  532.                      const xmlChar *lang);
  533. xmlChar *    xmlNodeGetBase        (xmlDocPtr doc,
  534.                      xmlNodePtr cur);
  535.  
  536. /*
  537.  * Removing content.
  538.  */
  539. int        xmlRemoveProp        (xmlAttrPtr attr); /* TODO */
  540. int        xmlRemoveNode        (xmlNodePtr node); /* TODO */
  541.  
  542. /*
  543.  * Internal, don't use
  544.  */
  545. void        xmlBufferWriteCHAR    (xmlBufferPtr buf,
  546.                      const xmlChar *string);
  547. void        xmlBufferWriteChar    (xmlBufferPtr buf,
  548.                      const char *string);
  549. void        xmlBufferWriteQuotedString(xmlBufferPtr buf,
  550.                      const xmlChar *string);
  551.  
  552. /*
  553.  * Saving
  554.  */
  555. void        xmlDocDumpMemory    (xmlDocPtr cur,
  556.                      xmlChar**mem,
  557.                      int *size);
  558. void        xmlDocDump        (FILE *f,
  559.                      xmlDocPtr cur);
  560. void        xmlElemDump        (FILE *f,
  561.                      xmlDocPtr cur,
  562.                      xmlNodePtr elem);
  563. int        xmlSaveFile        (const char *filename,
  564.                      xmlDocPtr cur);
  565.  
  566. /*
  567.  * Compression
  568.  */
  569. int        xmlGetDocCompressMode    (xmlDocPtr doc);
  570. void        xmlSetDocCompressMode    (xmlDocPtr doc,
  571.                      int mode);
  572. int        xmlGetCompressMode    (void);
  573. void        xmlSetCompressMode    (int mode);
  574.  
  575. #ifdef __cplusplus
  576. }
  577. #endif
  578.  
  579. #endif /* __XML_TREE_H__ */
  580.  
  581.